home *** CD-ROM | disk | FTP | other *** search
/ PC World Interactive 7 / PC World Interactive 7.iso / program / cprog.EXE / OBJ2ASM.ZIP / ORFIXUPP.C < prev    next >
Encoding:
C/C++ Source or Header  |  1991-10-01  |  6.5 KB  |  205 lines
  1. #include <stdio.h>
  2. #include "o.h"
  3.  
  4. extern int data_seg_idx;
  5. extern dword data_offset;
  6.  
  7. extern THREAD_T threads[2][4];
  8.  
  9. void fix_insert( int, int, int, long, int, int, int, int, int );
  10.  
  11. int fix_compare( rec_1, rec_2 )
  12.     FIX_T  *rec_1;
  13.     FIX_T  *rec_2;
  14. {
  15.     if ( rec_1->seg_idx > rec_2->seg_idx ) {
  16.         return( LEFT );
  17.     } else {
  18.         if ( rec_1->seg_idx < rec_2->seg_idx ) {
  19.             return( RIGHT );
  20.         } else {
  21.             if ( rec_1->dat_offset > rec_2->dat_offset ) {
  22.                 return( LEFT );
  23.             } else {
  24.                 if ( rec_1->dat_offset < rec_2->dat_offset ) {
  25.                     return( RIGHT );
  26.                 } else {
  27.                     if ( rec_1->offset > rec_2->offset ) {
  28.                         return( LEFT );
  29.                     } else {
  30.                         if ( rec_1->offset < rec_2->offset ) {
  31.                             return( RIGHT );
  32.                         } else {
  33.                             return( EQUAL );
  34.                         }
  35.                     }
  36.                 }
  37.             }
  38.         }
  39.     }
  40. }
  41.  
  42. void fix_insert( offset, relate, form, displacement, a_mode, a_index, 
  43.                                                     b_mode, b_index, extension )
  44.     int     offset;
  45.     int     relate;
  46.     int     form;
  47.     long    displacement;
  48.     int     a_mode;
  49.     int     a_index;
  50.     int     b_mode;
  51.     int     b_index;
  52.     int     extension;
  53. {
  54.     FIX_T   *fixup_rec;
  55.  
  56.     fixup_rec = (FIX_T *)o_malloc( sizeof(FIX_T) );
  57.     fixup_rec->seg_idx      = data_seg_idx;
  58.     fixup_rec->dat_offset   = data_offset;
  59.     fixup_rec->offset       = offset;
  60.     fixup_rec->relate       = relate;
  61.     fixup_rec->form         = form;
  62.     fixup_rec->displacement = displacement;
  63.     fixup_rec->a_mode       = a_mode;           /* Mode of frame   */
  64.     fixup_rec->a_index      = a_index;          /* Index of frame  */
  65.     fixup_rec->b_mode       = b_mode;           /* Mode of target  */
  66.     fixup_rec->b_index      = b_index;          /* Index of target */
  67.     fixup_rec->extended     = extension;
  68.  
  69. #ifdef DEBUG
  70. printf("FIXUP:%04X:%08lX:%04X displacement=%08lX\n",
  71.             data_seg_idx,data_offset,offset, displacement );
  72. #endif
  73.     if ( form == OFFSET || form == BASE || form == LOADOFF ) {
  74.         fixup_rec->word_sized = TRUE;
  75.     } else {
  76.         fixup_rec->word_sized = FALSE;
  77.     }
  78.  
  79.     insert( (char *)fixup_rec, fix_tree, TC fix_compare );
  80. }
  81.  
  82. int decode_fixup( relate, size, form, offset, extension )
  83.     int             relate;                 /* mode 0=self rel, 1=segment rel */
  84.     int             size;                   /* zero */
  85.     int             form;                   /* LOC value [0-4] */
  86.     int             offset;                 /* offset of data item */
  87.     int             extension;
  88. {
  89.     int             length;
  90.     int             fix;
  91.     int             thread;
  92.     int             a_mode;                 /* Mode of Frame   */
  93.     int             a_index;                /* Index of Frame  */
  94.     int             b_mode;                 /* Mode of Target  */
  95.     int             b_index;                /* Index of Target */
  96.     int             fbit;
  97.     int             tbit;
  98.     int             pbit;
  99.     dword   displacement;
  100.     int             extended;
  101.  
  102.     extended = FALSE;
  103.  
  104.     fix = get_byte();
  105.  
  106.     length = 1;
  107.     fbit   = ( fix & 0x80 ) >> 7;   /* F-bit field */
  108.     a_mode = ( fix & 0x70 ) >> 4;   /* frame index */
  109.     if ( fbit == 1 ) {
  110.         /* Reference a previously loaded thread fixup for location */
  111.         thread = ( a_mode & 0x03 );
  112.         a_index = threads[1][thread].index; /* mode is a thread # */
  113.         a_mode  = threads[1][thread].mode;
  114.     } else {
  115.         /* otherwise, frame is explicitly specified */
  116.         if ( a_mode < 4 ) {                 /* mode is not a thread # */
  117.             length += get_index( &a_index );
  118.         }
  119.     }
  120.     tbit   = ( fix & 0x08 ) >> 3;       /* T-bit field */
  121.     thread = ( fix & 0x07 );
  122.     pbit   = ( thread & 0x04 ) >> 2;    /* P-bit field */
  123.     b_mode = ( thread & 0x03 );         /* Target mode */
  124.     if ( tbit == 1 ) {
  125.         b_index = threads[0][b_mode].index; /* mode is a thread # */
  126.         b_mode  = threads[0][b_mode].mode & 0x03;
  127.     } else {
  128.         length += get_index( &b_index );    /* mode is not a thread # */
  129.     }
  130.  
  131.     if ( size != 0 && extension ) { /* size is always 0 for 16bit MS langs */
  132.         extended = TRUE;
  133.     }
  134.  
  135.     if ( pbit == 0 ) {
  136.         displacement = (dword)get_int();
  137.         length += 2;
  138.         if ( extended ) {
  139.             displacement += (dword)get_byte() << 16;
  140.             displacement += (dword)get_byte() << 24;
  141.             length += 2;
  142.         }
  143.     } else {
  144.         displacement = 0L;
  145.     }
  146.  
  147.     if ( a_mode == 5 ) {    /* don't process this type of fixupp */
  148.         a_mode = b_mode;
  149.         a_index = b_index;
  150.     }
  151.  
  152.     fix_insert( offset, relate, form, displacement, a_mode, a_index,
  153.                                                 b_mode, b_index, extended );
  154.     return( length );
  155. }
  156.  
  157.  
  158. void fixupp( length, extension )
  159.     word    length;
  160.     int             extension;
  161. {
  162.     uchar   type;           /* First byte of a FIXUPP packet */
  163.     int             kind;
  164.     int             thread;
  165.     int             locat;
  166.     int             relate;
  167.     int             size;
  168.     int             form;
  169.     int             offset;
  170.     int             mode;
  171.     int             index;
  172.  
  173.     --length;                           /* Subtract 1 for checksum */
  174.  
  175.     while ( length ) {
  176.         type = get_byte();
  177.         --length;
  178.         if ( type & 0x80 ) {
  179.             /*
  180.             ** True FixUp aka Explicit FixUp Record
  181.             */
  182.             --length;
  183.             locat = ((int)type << 8) + get_byte();
  184.             relate = ( locat & 0x4000 ) >> 14;  /* mode */
  185.             size   = ( locat & 0x2000 ) >> 13;  /* zero */
  186.             form   = ( locat & 0x1C00 ) >> 10;  /* LOC [0,4] */
  187.             offset = ( locat & 0x03FF );
  188.  
  189.             length -= decode_fixup( relate, size, form, offset, extension );
  190.         } else {
  191.             /*
  192.             ** Thread FixUp
  193.             */
  194.             kind   = ( type & 0x40 ) >> 6;
  195.             mode   = ( type & 0x1C ) >> 2;
  196.             thread = ( type & 0x03 );
  197.             threads[kind][thread].mode  = mode;
  198.             if ( mode == 0 || thread < 4 ) {
  199.                 length -= get_index( &index );
  200.                 threads[kind][thread].index = index;
  201.             }
  202.         }
  203.     }
  204. }
  205.